package cz.stv.pecinovsky.město;

import cz.stv.pecinovsky.správceplátna.Obdélník;
import cz.stv.pecinovsky.správceplátna.Přesouvač;
import cz.stv.pecinovsky.správceplátna.SprávcePlátna;

import cz.stv.pecinovsky.utility.Barva;
import cz.stv.pecinovsky.utility.IO;
import cz.stv.pecinovsky.utility.Pozice;

import java.util.ArrayList;
import java.util.List;


/*******************************************************************************
 * Testovací třída {@code ŠipkaTest}  slouží ke komplexnímu otestování
 * třídy {@link ŠipkaTest}.
 *
 * @author  Rudolf PECINOVSKÝ
 * @version 1.10.2678 — 2011-10-27
 */
public class ŠipkaTest extends junit.framework.TestCase
{
    private SprávcePlátna SP;
    private Šipka šipka0;
    private Šipka šipkaXY;
    private Šipka šipkaXYB;
    private Šipka šipkaXYM;
    private Šipka šipkaXYMB;



//== KONSTANTNÍ ATRIBUTY TŘÍDY =================================================
//== PROMĚNNÉ ATRIBUTY TŘÍDY ===================================================
//== STATICKÝ INICIALIZAČNÍ BLOK - STATICKÝ KONSTRUKTOR ========================
//== KONSTANTNÍ ATRIBUTY INSTANCÍ ==============================================
//== PROMĚNNÉ ATRIBUTY INSTANCÍ ================================================
//== PŘÍSTUPOVÉ METODY VLASTNOSTÍ TŘÍDY ========================================
//== OSTATNÍ NESOUKROMÉ METODY TŘÍDY ===========================================

//##############################################################################
//== KONSTRUKTORY A TOVÁRNÍ METODY =============================================

    /***************************************************************************
     * Vytvoří test se zadaným názvem.
     *
     * @param název  Název konstruovaného testu
     */
    public ŠipkaTest( String název )
    {
        super(název);
    }



//== PŘÍPRAVA A ÚKLID PŘÍPRAVKU ================================================

    /***************************************************************************
     * Inicializace předcházející spuštění každého testu a připravující tzv.
     * přípravek (fixture), což je sada objektů, s nimiž budou testy pracovat.
     */
    @Override
    protected void setUp()
    {
        šipka0     = new Šipka();
        šipkaXY    = new Šipka( 50,  50);
        šipkaXYB   = new Šipka(100, 100, Barva.MODRÁ);
        šipkaXYM   = new Šipka(  0, 100, 100);
        šipkaXYMB  = new Šipka(100,   0, 100, Barva.MODRÁ);

        SP = SprávcePlátna.getInstance();
        SP.přidej(šipka0);
        SP.přidej(šipkaXY);
        SP.přidej(šipkaXYB);
        SP.přidej(šipkaXYM);
        SP.přidej(šipkaXYMB);

        System.out.println("\n====== Instance v přípravku pro " + this +
                           "\n| SP: " + SP +
                           "\n| šipka0:    " + šipka0 +
                           "\n| šipkaXY:   " + šipkaXY +
                           "\n| šipkaXYB:  " + šipkaXYB +
                           "\n| šipkaXYM : " + šipkaXYM +
                           "\n| šipkaXYMB: " + šipkaXYMB +
                           "\n======");
        IO.zpráva("Šipky připraveny");
    }


    /***************************************************************************
     * Úklid po testu - tato metoda se spustí po vykonání každého testu.
     */
    @Override
    protected void tearDown()
    {
    }


//== SOUKROMÉ A POMOCNÉ METODY TŘÍDY ===========================================
//== SOUKROMÉ A POMOCNÉ METODY INSTANCÍ ========================================

    /***************************************************************************
     * Prohodí pozice zadaných šipek a nechá zkontrolovat,
     * zda si šipky své pozice doopravdy vyměnily.
     *
     * @param s1 První šipka
     * @param s2 Druhá šipka
     */
    private void pomProhoďPoziceSKontrolou(Šipka s1, Šipka s2)
    {
        s1.průsvitná();
        s2.průsvitná();
        TestUtility.prohoďPoziceSKontrolou(s1, s2);
        s1.vraťBarva();
        s2.vraťBarva();
    }



//== INTERNÍ DATOVÉ TYPY =======================================================
//== VLASTNÍ TESTY =============================================================
//
//     /***************************************************************************
//      *
//      */
//     public void testXXX()
//     {
//     }


    public void testPrůsvitná()
    {
        Obdélník podklad = new Obdélník(25, 25, 100, 100, Barva.BÍLÁ);
        SP.přidejPod(šipka0, podklad);

        šipka0   .průsvitná();
        šipkaXY  .průsvitná();
        šipkaXYB .průsvitná();
        šipkaXYM .průsvitná();
        šipkaXYMB.průsvitná();

        IO.zpráva("Ověř průsvitnost");

        šipka0   .vraťBarva();
        šipkaXY  .vraťBarva();
        šipkaXYB .vraťBarva();
        šipkaXYM .vraťBarva();
        šipkaXYMB.vraťBarva();
     }


    public void testPlynuléPosuny()
    {
        šipka0   .průsvitná();
        šipkaXY  .průsvitná();
        šipkaXYB .průsvitná();
        šipkaXYM .průsvitná();
        šipkaXYMB.průsvitná();
        Přesouvač p = new Přesouvač(10);
        p.přesunNa(250,   0, šipka0);
        p.přesunNa(250,  50, šipkaXY);
        p.přesunNa(250, 100, šipkaXYB);
        p.přesunNa(200, 100, šipkaXYM);
        p.přesunNa(200,   0, šipkaXYMB);
    }


    public void testPoziceVelikost()
    {
        Pozice sem = new Pozice(150, 150);
        int malý   = 25;
        int velký  = 150;

        TestUtility.poziceVelikost(šipka0,    sem, malý, velký);
        TestUtility.poziceVelikost(šipkaXY,   sem, malý, velký);
        TestUtility.poziceVelikost(šipkaXYB,  sem, malý, velký);
        TestUtility.poziceVelikost(šipkaXYM,  sem, malý, velký);
        TestUtility.poziceVelikost(šipkaXYMB, sem, malý, velký);
    }


    public void testProhoďPoziceSKontrolou()
    {
        pomProhoďPoziceSKontrolou(šipka0,   šipkaXYMB);
        pomProhoďPoziceSKontrolou(šipkaXYB, šipkaXYM);
        pomProhoďPoziceSKontrolou(šipkaXYM, šipka0);
    }


    /***************************************************************************
     * Vyzkouší schopnosti otočné šipky při objíždění okruhů.
     */
    public void testPojízdnost()
    {
        TestUtility.objeďOkruh(new Šipka());
    }


    /***************************************************************************
     * Vyzkouší schopnosti komparátoru ve třídě {@link TestUtility}
     * při řazení šipek.
     */
    public void testSeřaďSeznam()
    {
        List<IModulový> seznam = new ArrayList<IModulový>();
        seznam.add(šipka0);
        seznam.add(šipkaXY);
        seznam.add(šipkaXYB);
        seznam.add(šipkaXYM);
        seznam.add(šipkaXYMB);
        seznam.add(šipka0);
        TestUtility.seřaďSeznam(seznam);
    }


    /***************************************************************************
     * Vyzkouší schopnosti komparátoru ve třídě {@link TestUtility}
     * při řazení šipek.
     */
    public void testSeřaďSeznam2()
    {
//        List<IModulový> seznam = TestUtility.newListIModulový(
//                        šipka0, šipkaXY, šipkaXYB, šipkaXYM, šipkaXYMB, šipka0);
//        TestUtility.seřaďSeznam(seznam);
        TestUtility.seřaďSeznam(TestUtility.newListIModulový(
                    šipka0, šipkaXY, šipkaXYB, šipkaXYM, šipkaXYMB, šipka0));
    }

}
